//
// Copyright (C) 2024 EA group inc.
// Author: Jeff.li lijippy@163.com
// All rights reserved.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
//
//
// Created by jeff on 24-6-5.
//

#include <turbo/crypto/sha256.h>
#include <turbo/container/array_ref.h>
#include <turbo/base/endian.h>
#include <string.h>
#include <string.h>

namespace turbo {

#define SHR(x, c) ((x) >> (c))
#define ROTR(x, n) (((x) >> n) | ((x) << (32 - (n))))

#define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z)))
#define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))

#define SIGMA_0(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
#define SIGMA_1(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))

#define SIGMA_2(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))
#define SIGMA_3(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))

#define F_EXPAND(A, B, C, D, E, F, G, H, M1, M2, M3, M4, k)                    \
  do {                                                                         \
    H += SIGMA_1(E) + CH(E, F, G) + M1 + k;                                    \
    D += H;                                                                    \
    H += SIGMA_0(A) + MAJ(A, B, C);                                            \
    M1 += SIGMA_2(M2) + M3 + SIGMA_3(M4);                                      \
  } while (0);

    void SHA256::init() {
        InternalState.State[0] = 0x6A09E667;
        InternalState.State[1] = 0xBB67AE85;
        InternalState.State[2] = 0x3C6EF372;
        InternalState.State[3] = 0xA54FF53A;
        InternalState.State[4] = 0x510E527F;
        InternalState.State[5] = 0x9B05688C;
        InternalState.State[6] = 0x1F83D9AB;
        InternalState.State[7] = 0x5BE0CD19;
        InternalState.ByteCount = 0;
        InternalState.BufferOffset = 0;
    }

    void SHA256::hashBlock() {
        uint32_t A = InternalState.State[0];
        uint32_t B = InternalState.State[1];
        uint32_t C = InternalState.State[2];
        uint32_t D = InternalState.State[3];
        uint32_t E = InternalState.State[4];
        uint32_t F = InternalState.State[5];
        uint32_t G = InternalState.State[6];
        uint32_t H = InternalState.State[7];

        uint32_t W00 = InternalState.Buffer.L[0];
        uint32_t W01 = InternalState.Buffer.L[1];
        uint32_t W02 = InternalState.Buffer.L[2];
        uint32_t W03 = InternalState.Buffer.L[3];
        uint32_t W04 = InternalState.Buffer.L[4];
        uint32_t W05 = InternalState.Buffer.L[5];
        uint32_t W06 = InternalState.Buffer.L[6];
        uint32_t W07 = InternalState.Buffer.L[7];
        uint32_t W08 = InternalState.Buffer.L[8];
        uint32_t W09 = InternalState.Buffer.L[9];
        uint32_t W10 = InternalState.Buffer.L[10];
        uint32_t W11 = InternalState.Buffer.L[11];
        uint32_t W12 = InternalState.Buffer.L[12];
        uint32_t W13 = InternalState.Buffer.L[13];
        uint32_t W14 = InternalState.Buffer.L[14];
        uint32_t W15 = InternalState.Buffer.L[15];

        F_EXPAND(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x428A2F98);
        F_EXPAND(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x71374491);
        F_EXPAND(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xB5C0FBCF);
        F_EXPAND(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xE9B5DBA5);
        F_EXPAND(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x3956C25B);
        F_EXPAND(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x59F111F1);
        F_EXPAND(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x923F82A4);
        F_EXPAND(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0xAB1C5ED5);
        F_EXPAND(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xD807AA98);
        F_EXPAND(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x12835B01);
        F_EXPAND(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x243185BE);
        F_EXPAND(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x550C7DC3);
        F_EXPAND(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x72BE5D74);
        F_EXPAND(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x80DEB1FE);
        F_EXPAND(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x9BDC06A7);
        F_EXPAND(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC19BF174);

        F_EXPAND(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xE49B69C1);
        F_EXPAND(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xEFBE4786);
        F_EXPAND(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x0FC19DC6);
        F_EXPAND(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x240CA1CC);
        F_EXPAND(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x2DE92C6F);
        F_EXPAND(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4A7484AA);
        F_EXPAND(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5CB0A9DC);
        F_EXPAND(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x76F988DA);
        F_EXPAND(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x983E5152);
        F_EXPAND(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA831C66D);
        F_EXPAND(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xB00327C8);
        F_EXPAND(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xBF597FC7);
        F_EXPAND(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xC6E00BF3);
        F_EXPAND(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD5A79147);
        F_EXPAND(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x06CA6351);
        F_EXPAND(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x14292967);

        F_EXPAND(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x27B70A85);
        F_EXPAND(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x2E1B2138);
        F_EXPAND(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x4D2C6DFC);
        F_EXPAND(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x53380D13);
        F_EXPAND(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x650A7354);
        F_EXPAND(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x766A0ABB);
        F_EXPAND(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x81C2C92E);
        F_EXPAND(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x92722C85);
        F_EXPAND(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xA2BFE8A1);
        F_EXPAND(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA81A664B);
        F_EXPAND(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xC24B8B70);
        F_EXPAND(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xC76C51A3);
        F_EXPAND(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xD192E819);
        F_EXPAND(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD6990624);
        F_EXPAND(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xF40E3585);
        F_EXPAND(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x106AA070);

        F_EXPAND(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x19A4C116);
        F_EXPAND(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x1E376C08);
        F_EXPAND(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x2748774C);
        F_EXPAND(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x34B0BCB5);
        F_EXPAND(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x391C0CB3);
        F_EXPAND(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4ED8AA4A);
        F_EXPAND(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5B9CCA4F);
        F_EXPAND(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x682E6FF3);
        F_EXPAND(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x748F82EE);
        F_EXPAND(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x78A5636F);
        F_EXPAND(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x84C87814);
        F_EXPAND(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x8CC70208);
        F_EXPAND(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x90BEFFFA);
        F_EXPAND(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xA4506CEB);
        F_EXPAND(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xBEF9A3F7);
        F_EXPAND(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC67178F2);

        InternalState.State[0] += A;
        InternalState.State[1] += B;
        InternalState.State[2] += C;
        InternalState.State[3] += D;
        InternalState.State[4] += E;
        InternalState.State[5] += F;
        InternalState.State[6] += G;
        InternalState.State[7] += H;
    }

    void SHA256::addUncounted(uint8_t Data) {
        if constexpr (!is_little_endian())
            InternalState.Buffer.C[InternalState.BufferOffset] = Data;
        else
            InternalState.Buffer.C[InternalState.BufferOffset ^ 3] = Data;

        InternalState.BufferOffset++;
        if (InternalState.BufferOffset == BLOCK_LENGTH) {
            hashBlock();
            InternalState.BufferOffset = 0;
        }
    }

    void SHA256::writebyte(uint8_t Data) {
        ++InternalState.ByteCount;
        addUncounted(Data);
    }

    void SHA256::update(ArrayRef<uint8_t> Data) {
        InternalState.ByteCount += Data.size();

        // Finish the current block.
        if (InternalState.BufferOffset > 0) {
            const size_t Remainder = std::min<size_t>(
                    Data.size(), BLOCK_LENGTH - InternalState.BufferOffset);
            for (size_t I = 0; I < Remainder; ++I)
                addUncounted(Data[I]);
            Data = Data.drop_front(Remainder);
        }

        // Fast buffer filling for large inputs.
        while (Data.size() >= BLOCK_LENGTH) {
            assert(InternalState.BufferOffset == 0);
            static_assert(BLOCK_LENGTH % 4 == 0);
            constexpr size_t BLOCK_LENGTH_32 = BLOCK_LENGTH / 4;
            for (size_t I = 0; I < BLOCK_LENGTH_32; ++I)
                InternalState.Buffer.L[I] = turbo::big_endian::load32(&Data[I * 4]);
            hashBlock();
            Data = Data.drop_front(BLOCK_LENGTH);
        }

        // Finish the remainder.
        for (uint8_t C: Data)
            addUncounted(C);
    }

    void SHA256::update(std::string_view Str) {
        update(
                ArrayRef<uint8_t>((uint8_t *) const_cast<char *>(Str.data()), Str.size()));
    }

    void SHA256::pad() {
        // Implement SHA-2 padding (fips180-2 5.1.1)

        // Pad with 0x80 followed by 0x00 until the end of the block
        addUncounted(0x80);
        while (InternalState.BufferOffset != 56)
            addUncounted(0x00);

        uint64_t len = InternalState.ByteCount << 3; // bit size

        // Append length in the last 8 bytes big edian encoded
        addUncounted(len >> 56);
        addUncounted(len >> 48);
        addUncounted(len >> 40);
        addUncounted(len >> 32);
        addUncounted(len >> 24);
        addUncounted(len >> 16);
        addUncounted(len >> 8);
        addUncounted(len);
    }

    void SHA256::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {
        // Pad to complete the last block
        pad();

        if constexpr (!is_little_endian()) {
            // Just copy the current state
            for (int i = 0; i < 8; i++) {
                HashResult[i] = InternalState.State[i];
            }
        } else {
            // Swap byte order back
            for (int i = 0; i < 8; i++) {
                HashResult[i] = turbo::gbswap_32(InternalState.State[i]);
            }
        }
    }

    std::array<uint8_t, 32> SHA256::final() {
        union {
            std::array<uint32_t, HASH_LENGTH / 4> HashResult;
            std::array<uint8_t, HASH_LENGTH> ReturnResult;
        };
        static_assert(sizeof(HashResult) == sizeof(ReturnResult));
        final(HashResult);
        return ReturnResult;
    }

    std::array<uint8_t, 32> SHA256::result() {
        auto StateToRestore = InternalState;

        auto Hash = final();

        // Restore the state
        InternalState = StateToRestore;

        // Return pointer to hash (32 characters)
        return Hash;
    }

    std::array<uint8_t, 32> SHA256::hash(ArrayRef<uint8_t> Data) {
        SHA256 Hash;
        Hash.update(Data);
        return Hash.final();
    }

} // namespace turbo
